GermanWikipedia - /page/entry.mu

Micron Document

`:top

Ein `!FPGA`! (`F33f`_`[Akronym`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Akronym]`_`f für `!Field Programmable Gate Array`!) ist ein `F33f`_`[integrierter Schaltkreis`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Integrierter_Schaltkreis]`_`f (IC) der `F33f`_`[Digitaltechnik`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digitaltechnik]`_`f, in welchen eine `F33f`_`[logische Schaltung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierbare_logische_Schaltung]`_`f geladen werden kann. Die Bezeichnung kann übersetzt werden als `*im Feld`* (also vor Ort, beim Kunden) `*programmierbare `F33f`_`[(Logik-)Gatter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Logikgatter]`_`f-Anordnung`*.

Anders als bei der Programmierung von `F33f`_`[Computern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computer]`_`f, `F33f`_`[Mikrocontrollern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mikrocontroller]`_`f oder Steuerungen bezieht sich hier der Begriff `F33f`_`[Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f nicht nur auf die Vorgabe zeitlicher Abläufe, sondern vor allem auch auf die Definition der gewünschten Schaltungsstruktur. Diese wird mittels einer `F33f`_`[Hardwarebeschreibungssprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hardwarebeschreibungssprache]`_`f formuliert und von einer Erzeugersoftware in eine Konfigurationsdatei übersetzt, welche vorgibt, wie die physischen Elemente im FPGA verschaltet werden sollen. Man spricht daher auch von der Konfiguration des FPGA. Ohne diese hat der Baustein keine Funktion.

FPGAs stellen eine Weiterentwicklung der `F33f`_`[PLDs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierbare_logische_Schaltung]`_`f dar und kommen in vielen Gebieten der digitalen Elektronik zum Einsatz.

>>Contents

• `F0af`_`[Anwendung`#anwendung]`_`f

• `F0af`_`[Aufbau und Struktur`#aufbau-und-struktur]`_`f

• `F0af`_`[Weitere Komponenten`#weitere-komponenten]`_`f

• `F0af`_`[Unterschiede zu CPLDs`#unterschiede-zu-cplds]`_`f

• `F0af`_`[Konfiguration`#konfiguration]`_`f

• `F0af`_`[Entwurfsschritte und -werkzeuge`#entwurfsschritte-und-werkzeuge]`_`f

• `F0af`_`[Schaltungsentwurf`#schaltungsentwurf]`_`f

• `F0af`_`[Simulation`#simulation]`_`f

• `F0af`_`[Implementierung und Test`#implementierung-und-test]`_`f

• `F0af`_`[Anwendungsbeispiele`#anwendungsbeispiele]`_`f

• `F0af`_`[Geschichte`#geschichte]`_`f

• `F0af`_`[Vergleiche`#vergleiche]`_`f

• `F0af`_`[Mikroprozessoren`#mikroprozessoren]`_`f

• `F0af`_`[Vor- und Nachteile im Vergleich zu anwendungsspezifischen integrierten Schaltungen (ASIC)`#vor-und-nachteile-im-vergleich-zu-anwendungsspezifischen-integrierten-schaltungen-asic]`_`f

• `F0af`_`[Hersteller von FPGAs`#hersteller-von-fpgas]`_`f

• `F0af`_`[Siehe auch`#siehe-auch]`_`f

• `F0af`_`[Literatur`#literatur]`_`f

• `F0af`_`[Weblinks`#weblinks]`_`f

• `F0af`_`[Einzelnachweise`#einzelnachweise]`_`f

-─

>>Anwendung

Durch Konfiguration der intern vorhandenen Elemente können in einem FPGA verschiedene Schaltungen und Funktionen realisiert werden. Diese reichen von Schaltungen geringer Komplexität, wie z. B. ein einfacher `F33f`_`[Synchronzähler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Synchronzähler]`_`f oder Interfaces für Digitalbausteine (z. B. `F33f`_`[Glue Logic`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Glue_Logic]`_`f), über `F33f`_`[Speichercontroller`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Speichercontroller]`_`f und vollständige `F33f`_`[Mikroprozessoren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mikroprozessor]`_`f bis hin zu hochkomplexen Schaltungen wie `F33f`_`[Systems-on-a-Chip`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=System-on-a-Chip]`_`f.

FPGAs werden in allen Bereichen der Digitaltechnik eingesetzt, vor allem aber dort, wo es auf schnelle `F33f`_`[digitale Signalverarbeitung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digitale_Signalverarbeitung]`_`f und flexible Änderung der Schaltung ankommt, um beispielsweise nachträgliche Verbesserungen an den implementierten Funktionen vornehmen zu können, ohne dabei direkt die Hardware ändern zu müssen. Ein großes Anwendungsgebiet ist die Erstellung von Prototypen in der `F33f`_`[ASIC`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anwendungsspezifische_integrierte_Schaltung]`_`f-Entwicklung zum vorherigen Test sowie auch der Bereich Maintenance bzw. `F33f`_`[Obsoleszenzmanagement`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Obsoleszenzmanagement]`_`f, in dem es darum geht, Ersatz für alte, nicht mehr lieferbare digitale Bausteine oder `F33f`_`[Mikrocontroller`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mikrocontroller]`_`f vorzuhalten.

Mit der Einführung der FPGAs wurden kompakte, anwenderspezifische Schaltungen in geringen Stückzahlen ermöglicht. Heute gestatten sie die preiswerte und flexible Fertigung komplexer Systeme wie `F33f`_`[Mobilfunk`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mobilfunk]`_`f-`F33f`_`[Basisstationen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Basisstation]`_`f als Alternative zur teureren Auftragsfertigung durch Halbleiterhersteller.

Neben den FPGAs existieren auch `F33f`_`[FPAAs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Field_Programmable_Analog_Array]`_`f (Field Programmable Analog Array), die nicht nur digitale, sondern vor allem `F33f`_`[analoge`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Analogtechnik]`_`f Funktionsblöcke enthalten, die vom Anwender programmiert und verschaltet werden können. Es handelt sich dabei in erster Linie um `F33f`_`[Filter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Filter_(Elektrotechnik)]`_`f und `F33f`_`[HF-Bauelemente`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hochfrequenztechnik]`_`f.`:cite-ref-1[`F5bf`_`[1`#cite-note-1]`_`f]

>>Aufbau und Struktur

Die wesensbestimmende Grundstruktur eines FPGA ist ein Feld (englisch Array) aus Basisblöcken mit jeweils einer einfachen programmierbaren `F33f`_`[Lookup-Tabelle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Lookup-Tabelle]`_`f (LUT) und einem 1-Bit-Register (`F33f`_`[Flipflop`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Flipflop]`_`f). Die LUTs können, je nach Anzahl der verfügbaren Eingänge, jede `*beliebige`* n-stellige Binärfunktion realisieren. Die Programmierung der gewünschten Funktion erfolgt durch die Hinterlegung der definierenden `F33f`_`[Wahrheitstabelle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Wahrheitstabelle]`_`f in den `F33f`_`[SRAM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Static_random-access_memory]`_`f-Zellen der LUT, die Funktionsberechnung durch das Auslesen der durch die Eingänge bestimmten Speicheradresse. Lange Zeit waren LUT-Strukturen mit 4 binären Eingängen üblich. Neuere FPGAs gehen zur Verringerung des Aufwandes an LUT-zu-LUT-Verbindungen zur Realisierung von Funktionen mit mehr Eingängen auf LUTs mit bis zu 6 Eingängen über.

Neben den LUTs ist auf einem FPGA auch die Verschaltung der Komponenten weitgehend frei konfigurierbar. `F33f`_`[Multiplexer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Multiplexer]`_`f-Strukturen in den Basisblöcken ermöglichen häufig sehr schnelle lokale Signalpfade, zur Einbindung oder Umgehung des Flipflops, zur Rückkopplung von dessen Ausgang, zur Verbindung von Nachbarblöcken und ähnlichem. Für die ferneren Verbindungen liegt zwischen den Basisblöcken ein Gitter aus immensen Busstrukturen, an das Ein- und Ausgänge angeschlossen werden können. Weitere programmierbare Schaltkomponenten in den Kreuzungspunkten des Gitters erlauben die Signalverteilung über den gesamten Chip.

>>>Weitere Komponenten

Weitere oft vorzufindende Elemente von FPGA sind:

• `*Eingangs-/Ausgangs-Blöcke`* (englisch `*IO-Blocks`* oder `*IOB`*) dienen der Kommunikation mit der Außenwelt. Über sie werden die externen Anschlüsse des FPGA mit der internen Schaltmatrix verbunden. Sie können an die jeweilige Anwendung angepasst werden, z. B. kann die Ausgangsspannung für den jeweiligen Standard eingestellt werden (`F33f`_`[TTL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Transistor-Transistor-Logik]`_`f/`F33f`_`[CMOS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Complementary_metal-oxide-semiconductor]`_`f usw.). Spezielle IOB-Blöcke mit integrierten Serializern gestatten die Anbindung an Hochgeschwindigkeits-Busse und `F33f`_`[Double-Data-Rate`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Double_Data_Rate]`_`f-(DDR)-Schnittstellen.

• Ein oder mehrere `*Taktgeneratoren`* erzeugen, ausgehend von an den Eingängen zur Verfügung gestellten `F33f`_`[Taktsignalen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Taktsignal]`_`f, alle für die Anwendung benötigten internen Taktsignale. Diese können gegenüber den Eingangstaktsignalen in der Phase verschoben sein und besitzen eine von dem jeweiligen Eingangstaktsignal abgeleitete Frequenz. `*Taktverstärker`* sowie eine entsprechende Verschaltung sorgen dafür, dass jedes verwendete Taktsignal überall im Chip synchron zur Verfügung steht. Moderne FPGAs besitzen typischerweise mehrere `F33f`_`[Phase-locked loops`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Phase-locked_loop]`_`f (PLL), mit denen sich rational gebrochene Taktfrequenzteilungen/-vervielfachungen erzeugen lassen. Den gleichen Zweck erfüllen `F33f`_`[Delay-locked loops (DLL)`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Delay-Locked_Loop]`_`f und digital frequency synthesizer (DFS), die manche FPGA-Hersteller gegenüber der PLL bereitstellen.

• In vielen FPGAs sind zusätzliche festverdrahtete Funktionen enthalten, wie z. B. Speicherblöcke (sog. `*Block `F33f`_`[RAM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Random-Access_Memory]`_`f`*), die sich in vielfältiger Weise nutzen lassen.

• Für Aufgaben der `F33f`_`[digitalen Signalverarbeitung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digitale_Signalverarbeitung]`_`f sind viele FPGAs zusätzlich zu den normalen Logikzellen mit DSP-Blöcken ausgestattet.`:cite-ref-xilinxdsp-2-0[`F5bf`_`[2`#cite-note-xilinxdsp-2]`_`f]`:cite-ref-alteradsp-3-0[`F5bf`_`[3`#cite-note-alteradsp-3]`_`f] Diese erlauben, neben der schnellen Multiplikation zweier Zahlen, auch die Verwendung als `F33f`_`[Multiply-Accumulate`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Multiply-Accumulate]`_`f-Blöcke, wie sie insbesondere für `F33f`_`[digitale Filter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digitales_Filter]`_`f und andere `F33f`_`[Faltungsoperationen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Faltung_(Mathematik)]`_`f benötigt werden. Dies ist häufig effizienter, als die zugrundeliegende Funktion aus den universellen Logik-Ressourcen des FPGA zu synthetisieren.

• FPGAs, die aufwändige Berechnungen vollziehen sollen, verfügen über mehrere integrierte `F33f`_`[Mikrocontroller`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mikrocontroller]`_`f in Form eines `F33f`_`[Hard-Cores`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IP-Core]`_`f, welcher z. B. mit einem C-Programm programmiert werden kann.

• FPGAs, die besonders hohe Speicheranforderungen haben, besitzen mehrere integrierte DDR-Speichercontroller und neben dem FPGA im gleichen Gehäuse installierte DDR-SDRAM-Blöcke mit mehreren GB Speicherkapazität. Man nennt solche integrierten Schaltungen mit mehreren Chips in einem Gehäuse auch `F33f`_`[Multi-Die`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Die_(Halbleitertechnik)]`_`f.

• Durch weiteres Hinzufügen von komplexen Funktionsblöcken wie `F33f`_`[Ethernetschnittstellen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ethernet]`_`f, `F33f`_`[USB`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Universal_Serial_Bus]`_`f-Controllern und DDR-Speichercontrollern entstehen `F33f`_`[System-on-a-Chip-Systeme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=System-on-a-Chip]`_`f (SoCs), die den Aufbau vollständiger computerähnlicher Systeme ermöglichen. Die darin verwendeten unveränderlichen Schaltungen belegen sehr viel weniger Chipfläche, als die gleiche Funktion benötigt, wenn sie mit frei konfigurierbaren Logikblöcken realisiert wird. Sie sind auch erheblich stromsparender und um ein Mehrfaches schneller.

• Hersteller wie `F33f`_`[Xilinx`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Xilinx]`_`f bieten mittlerweile auch FPGAs an, die bereits über im Chipgehäuse untergebrachten Flash-Speicher zur Konfiguration verfügen und keinen externen Flash-Speicher mehr benötigen. Die Lade- bzw. Startzeiten des FPGA bleiben im Vergleich zu externem Speicher in etwa gleich, sind allerdings speziell vom Hersteller optimiert. Ein weiterer Vorteil ist der Schutz vor unrechtmäßigen Kopien durch das Auslesen des extern befindlichen Speichers. Derzeit und auf absehbare Zeit ist es technologisch nicht möglich, die SRAM-basierten Schalterzellen in einem FPGA direkt wie bei den viel einfacheren `F33f`_`[CPLDs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=CPLD]`_`f durch Flash- bzw. `F33f`_`[EEPROM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=EEPROM]`_`f-Zellen zu ersetzen.

>>>Unterschiede zu CPLDs

Oft werden FPGAs mit den digitalen und ebenfalls rekonfigurierbaren `F33f`_`[CPLD`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=CPLD]`_`f-Bausteinen (Complex Programmable Logic Devices) gleichgesetzt bzw. verglichen. Die wesentlichen Unterschiede zwischen FPGAs und CPLDs sind:

• CPLD gehört noch zur Gruppe der PAL (Programmable Array Logic) / PLA (Programmable Logic Array) / PLD (Programmable Logic Device) / GAL (Generic Array Logic), hat aber einen komplizierteren Innenaufbau im IC als PAL und GAL. Die noch neueren FPGAs gehören hingegen zu einer anderen Technologie`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f]. CPLDs weisen im Vergleich zu FPGAs eine wesentlich einfachere Struktur auf. Sie besitzen kein feinmaschiges Array (Feld) von Logikblöcken und Flipflops, sondern nur eine konfigurierbare Schaltmatrix, die verschiedene Eingangssignale zu verschiedenen Ausgangssignalen verbinden kann. Die Signale können dabei durch logische Operationen wie `F33f`_`[AND`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Und-Gatter]`_`f/`F33f`_`[OR`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Oder-Gatter]`_`f verknüpft werden. Dadurch haben CPLDs eine vom jeweiligen Design unabhängige, konstante Signaldurchlaufzeit. Durch entsprechende Designmethoden kann auch bei FPGAs eine definierte maximale Durchlaufzeit erreicht werden (englisch `*timing constraints`*).

• CPLDs weisen vergleichsweise wenige Flipflops auf. Vor allem längere Schieberegister, Zähler, Zustandsspeicher und ähnliche Schaltungen, die viele Flipflops benötigen, sind in CPLDs nur ineffizient zu realisieren.

• CPLDs besitzen, da jeder IO-Pin ein Flipflop besitzt, meist sehr viele IO-Pins, die in vielen Anwendungen nur teilweise verwendet werden. In Anwendungen, in denen nur vergleichsweise einfache digitale Schaltungen, sogenannte `*`F33f`_`[glue logic`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Glue_Logic]`_`f`*, mit einem hohen Bedarf an IO-Pins Verwendung findet, sind CPLDs meist die bessere Wahl.

• CPLDs können durch ihre einfache Struktur technologisch mit `F33f`_`[Flash-Zellen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Flash-Speicher]`_`f in den Schaltmatrizen arbeiten. Damit ist ein CPLD sofort nach dem Einschalten (englisch Power-Up) betriebsbereit, während rekonfigurierbare FPGAs mit `F33f`_`[SRAM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Static_random-access_memory]`_`f-basierenden Zellen erst einen Ladezyklus für die Konfiguration durchlaufen müssen. Von einigen Herstellern gibt es aber seit längerem auch FPGAs in Flash-Technik. Seit Ende der 1990er Jahre ist bei den CPLDs eine Annäherung an die FPGA-SRAM-Technologie zu beobachten. Heute arbeiten die meisten CPLDs intern SRAM-basiert. Bei einigen CPLD-Familien besteht inzwischen das logische Grundelement aus dem FPGA-typischen LUT4-Flipflop-Verbund (Altera MAX II-Serie).

• CPLDs weisen durch den einfacheren Aufbau und die geringere Größe auch einen wesentlich geringeren Stromverbrauch auf.

>>>Konfiguration

Die Programmierung der Logikelemente kann je nach FPGA unterschiedlich gelöst werden. Man kann zwischen Methoden unterscheiden, die es ermöglichen, den FPGA mehrmals zu programmieren, und Methoden, die nur eine einmalige Programmierung zulassen. Bei den mehrmals programmierbaren FPGAs wird die Konfiguration in Speicherzellen (z. B. `F33f`_`[SRAM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Static_random-access_memory]`_`f, `F33f`_`[EPROM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Erasable_Programmable_Read-Only_Memory]`_`f, `F33f`_`[EEPROM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Electrically_Erasable_Programmable_Read-Only_Memory]`_`f, `F33f`_`[Flash`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Flash-Speicher]`_`f) gespeichert. Bei den einmalig programmierbaren FPGAs werden die physikalischen Eigenschaften der Verbindungswege permanent geändert (`F33f`_`[Antifuse-Technologie`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Antifuse-Technologie]`_`f). Diese Technologie bietet im Feld eine größere Sicherheit gegen äußere Störungen.

Die Konfiguration der LUTs und der Verbindungsstrukturen bei SRAM-basierten FPGAs erfolgt typischerweise einmal vor jedem Einsatz, wodurch der FPGA auf eine konkrete Funktion festgelegt wird. Das ist notwendig, da der FPGA durch Abschalten der Betriebsspannung seine Konfiguration wieder verliert. Im Einsatz steht dem FPGA deshalb meist eine Art `F33f`_`[EPROM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Erasable_Programmable_Read-Only_Memory]`_`f zur Seite, das die Konfiguration vorhält und dessen Inhalt selbst auch `F33f`_`[aktualisierbar`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Softwareaktualisierung]`_`f ist. Der FPGA kann sich selbst aus diesem nichtflüchtigen Speicher beladen. Alternativ kann die Konfiguration auch aktiv durch einen Microcontroller oder einen anderen FPGA erfolgen, der die Konfiguration in den FPGA schreibt.

In der Regel behält der FPGA seine Funktion dann bis zum Abschalten bei. Mehr und mehr wird aber auch eine bereichsweise Umprogrammierung von einzelnen FPGA-Bereichen im laufenden Betrieb unterstützt, um den Platz im FPGA effektiver zu nutzen und eigentlich festverdrahtete Funktionen zu flexibilisieren.

Der Vorgang des Konfigurierens des FPGAs wird oft auch als Programmieren bezeichnet, was jedoch eine begriffliche Überschneidung mit dem Entwurf bedingt.

>>Entwurfsschritte und -werkzeuge

Oftmals wird bei der Entwicklung von FPGA-Schaltungen von `*Programmierung`* gesprochen. Der Begriff ist in diesem Kontext aber anders zu verstehen, als es von der Erstellung von Software für Prozessoren her bekannt ist. Im Rahmen des Entwicklungsprozesses erfolgt zunächst ein Schaltungsentwurf, gefolgt von einer Prüfung der entstandenen Hardwarebeschreibung mittels Simulationswerkzeugen und dann eine Implementierung (`*Place and Route`*) sowie ggf. laufzeitbasierende Simulation. Erst danach kann die implementierte Schaltung am realen FPGA erprobt werden.

>>>Schaltungsentwurf

Erstellt wird die Konfiguration eines FPGA entweder grafisch mittels eines `F33f`_`[Schaltplans`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schaltplan]`_`f (englisch `*schematic`*) oder textuell mit einer `F33f`_`[Hardwarebeschreibungssprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hardwarebeschreibungssprache]`_`f. Dies sind primär `F33f`_`[VHDL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Very_High_Speed_Integrated_Circuit_Hardware_Description_Language]`_`f oder `F33f`_`[Verilog`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Verilog]`_`f, welche die gesamte Funktion der Schaltung in Form von Strukturen und Abläufen beschreibt. Die Strukturen und die Verschaltung derselben kann dabei durch Text oder graphische Werkzeuge erfolgen, die ähnlich einem Schaltplaneditor arbeiten. Ein typisches Werkzeug ist der HDL-Designer. Daneben bieten fast alle Hersteller in ihrer tool chain grafische Entwurfswerkzeuge an.

Die im FPGA erforderlichen Ablaufsteuerungen lassen sich durch `F33f`_`[endliche Automaten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Endlicher_Automat]`_`f darstellen. Der beschreibende Code wird entweder als HDL eingegeben oder ebenfalls mit einem grafischen Entwurfswerkzeug in einem Zwischenschritt automatisch erzeugt.

Darüber hinaus lassen sich mit herstellerunabhängigen grafischen Programmiersystemen wie `F33f`_`[LabVIEW`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=LabVIEW]`_`f, `F33f`_`[Matlab`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Matlab]`_`f/`F33f`_`[Simulink`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Simulink]`_`f oder dem kostenfreien Logiflash`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f] Schaltungsmodule und Abläufe für einen FPGA automatisch erstellen.

In den letzten Jahren versuchten mehrere Projekte, Hardwareimplementierungen für `F33f`_`[ASICs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anwendungsspezifische_integrierte_Schaltung]`_`f, FPGAs und `F33f`_`[CPLDs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Complex_Programmable_Logic_Device]`_`f mit der `F33f`_`[Programmiersprache C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f (HardwareC, HandelC, BachC) zu beschreiben. Aktuelle Ansätze bauen direkt auf den weit verbreiteten Standardsprachen ANSI C bzw. `F33f`_`[C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++]`_`f oder `F33f`_`[Python`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Python_(Programmiersprache)]`_`f (mit MyHDL`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f]) auf. Für `F33f`_`[SystemC`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SystemC]`_`f existieren keine Synthesetools, der praktische Nutzen für konkrete FPGA-Entwicklungen liegt bei der abstrakten Verhaltensmodellierung und deutlich beschleunigten Systemsimulationen, weshalb es dort zum weitverbreiteten Industriestandard avanciert ist. Es gibt auch High-Level-Synthese-Werkzeuge, um aus Hochsprachen (C/C++, MATLAB, `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f, `F33f`_`[Python`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Python_(Programmiersprache)]`_`f, `F33f`_`[UML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Unified_Modeling_Language]`_`f) einen Entwurf auf `F33f`_`[Registertransferebene`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Registertransferebene]`_`f (`F33f`_`[VHDL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Very_High_Speed_Integrated_Circuit_Hardware_Description_Language]`_`f, `F33f`_`[Verilog`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Verilog]`_`f) zu erzeugen. Beispiele sind Catapult C Synthesis von `F33f`_`[Mentor Graphics`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mentor_Graphics]`_`f, CoDeveloper von Impulse Accelerated Technologies, Cynthesizer von Forte Design Systems oder das oben erwähnte freie MyHDL.

Herstellerspezifische Sprachen wie Altera-HDL (AHDL) oder auch die kaum noch verwendete Hardwarebeschreibungssprache `F33f`_`[ABEL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Advanced_Boolean_Expression_Language]`_`f wurden ebenso genutzt wie UDL/I (Japan).

Zur Integration `F33f`_`[eingebetteter Systeme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Eingebettetes_System]`_`f in FPGAs gibt es Werkzeuge, die eine Konstruktion auf Funktionsblockebene anbieten, z. B. Xilinx EDK (Embedded Development Kit). Funktionsblöcke wie `F33f`_`[FIFOs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=First_In_–_First_Out]`_`f, Prozessoren, serielle Schnittstellen, Ethernet-MAC-Layer, RAM-Controller, Parallel-IO etc. werden vom Hersteller zur Verfügung gestellt. Diese Funktionseinheiten, `F33f`_`[IP-Core`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IP-Core]`_`f genannt, liegen manchmal als Quellcode, oder meist als verschlüsselte Netzliste vor und sind in der Regel parametrierbar (z. B. Baudrate bei seriellen asynchronen Schnittstellen oder Fifo-Tiefe oder Breite der Parallelschnittstelle). Diese werden über Busse mit anderen Funktionseinheiten verbunden.

Für FPGAs wird beim Schaltungsentwurf ein synchrones `F33f`_`[Schaltungsdesign`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schaltungsdesign]`_`f empfohlen, wenngleich nicht zwingend erforderlich. Das bedeutet: An allen `F33f`_`[Flipflops`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Flipflop]`_`f in einer sogenannten `*Takt-Domäne`* (englisch `*clock domain`*) liegt der gleiche Takt. Gesteuert wird die Datenübernahme in ein FPGA-Flipflop am besten nur über die zusätzlich vorhandenen `*Clock Enable`*-Eingänge und nicht über geteilte Taktsignale (englisch `*gated clocks`*). Das vermeidet schwer handhabbare Laufzeiteffekte. Manche FPGAs bieten spezielle Umschalter an, die das garantiert störungsfreie (`F33f`_`[glitch-freie`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Glitch_(Elektronik)]`_`f) Wechseln zwischen verschiedenen Taktquellen im Betrieb erlauben.

>>>Simulation

Nach und während der Erstellung der Beschreibung erfolgt regelmäßig eine funktionale `F33f`_`[Simulation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schaltungssimulation]`_`f in der Entwicklungssoftware, bei der sichergestellt wird, dass die gewünschten Abläufe eingehalten und alle Elemente korrekt verbunden sind. Die erstellte Hardwarebeschreibung wird dazu wie ein konventionelles Programm interpretiert, compiliert und von einer Simulationssoftware ausgeführt. Dabei handelt es sich entweder um eine interne Komponente der Entwicklungssoftware oder ein externes Programm, wie z. B. ModelSim.`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f] Das Augenmerk liegt bei diesem Schritt hauptsächlich auf der logischen Schaltungsfunktion. Es wird z. B. geprüft, dass Schaltfunktionen unter allen Randbedingungen in der gewünschten Weise ablaufen und Ergebnisse, die in Registern gespeichert werden, zum richtigen Zeitpunkt gelesen und verrechnet werden. Dazu wird für die gesamte Schaltung und bedarfsweise einzelne Module eine Testbench erstellt, welche das Logikdesign mit Daten füttert und unterschiedliche Betriebsfälle abdeckt.

>>>Implementierung und Test

Ausgehend von einer verifizierten Logikschaltung erfolgt dann ein Umsetzen der Netzliste für das konkrete FPGA, wobei auch externe Funktionsblöcke, die von Drittanbietern angeboten werden und bisher nur als black box existierten, eingefügt werden. Ebenso können bei diesem Schritt Teilschaltungen, die zum Testen des FPGAs gedacht sind, wie integrierte Logic Analyzer, hinzugefügt werden. Ein sogenanntes `F33f`_`[Synthesewerkzeug`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Synthese_(Elektrotechnik)]`_`f führt dazu diese Beschreibung wie ein Programm aus und erstellt in mehreren Schritten für den gewünschten Baustein eine spezifische `F33f`_`[Netzliste`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Netzliste]`_`f unter Nutzung der in diesem Baustein verfügbaren Ressourcen.

Unter Anwendung weiterer Randbedingungen wie Platzierungsanweisungen und Zeitvorgaben, erfolgt dann letztlich das Verteilen der Funktionsblöcke für den konkreten FPGA. Nach diesem Schritt können konkrete Annahmen über das Laufzeitverhalten gemacht werden (statische Timing-Analyse) und so die Einhaltung zeitlicher Anforderungen, insbesondere der Setz- und Haltezeiten (`F33f`_`[englisch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Englische_Sprache]`_`f setup time und `F33f`_`[englisch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Englische_Sprache]`_`f hold time), überprüft werden. Zeigt die Analyse Abweichungen (`F33f`_`[englisch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Englische_Sprache]`_`f timing violations), muss die Hardwarebeschreibung geändert und das Design neu synthetisiert werden, unter Umständen mehrmals. Danach folgt das Umsetzen in eine Binärdatei (`F33f`_`[englisch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Englische_Sprache]`_`f programming file) zum Konfigurieren des FPGAs. Sofern vorgesehen, wird in einem weiteren Schritt eine Binärdatei zum Beladen des Flash-Speichers erzeugt.

>>Anwendungsbeispiele

FPGAs haben seit ihren Anfängen ihren Anwendungsbereich von der klassischen „`F33f`_`[Glue-Logic`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Glue_Logic]`_`f“, also der reinen Verbindungslogik zwischen verschiedenen digitalen Bausteinen, zunehmend erweitert und werden heute auch bei mittleren Stückzahlen für die Realisierung komplexer digitaler Schaltungen bis hin zu kompletten digitalen Systemen eingesetzt. Durch die Rekonfigurierbarkeit von FPGAs direkt beim Endanwender besteht darüber hinaus der wesentliche Vorteil, auf aktuelle technische Entwicklungen reagieren zu können und die digitalen Schaltungen durch Updates anpassen zu können, ohne direkt die zugrundeliegende Hardware der FPGA-Chips verändern zu müssen.

FPGAs werden beispielsweise zur Echtzeit-Verarbeitung von einfachen bis komplexen Algorithmen genutzt, zur `F33f`_`[digitalen Signalverarbeitung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digitale_Signalverarbeitung]`_`f im Rahmen von `F33f`_`[digitalen Filtern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digitales_Filter]`_`f oder zur `F33f`_`[schnellen Fourier-Transformation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schnelle_Fourier-Transformation]`_`f. Aber auch Protokoll-Implementierungen wie Teile des `F33f`_`[Ethernet`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ethernet]`_`f-MAC-Layers, die Kodierung von digitalen Videosignalen, die Verschlüsselung von Daten und `F33f`_`[Fehlerkorrekturverfahren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fehlerkorrekturverfahren]`_`f sind Anwendungsgebiete.

Besonders in Bereichen, in denen Algorithmen bzw. Protokolle einer schnellen Weiterentwicklung unterliegen, ist die Verwendung rekonfigurierbarer FPGAs statt ASICs angebracht. Die Vorteile sind schnelle Marktreife, die Möglichkeit nachfolgender Fehlerbehebungen, Anpassung an neue Entwicklungen.

Für einige Klassen von Rechenproblemen sind auch FPGA-basierte Parallelcomputer sehr geeignet. Das wahrscheinlich bekannteste Beispiel sind FPGA-Rechner zum Brechen kryptographischer Verfahren, wie dem `F33f`_`[Data Encryption Standard`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Data_Encryption_Standard]`_`f (DES). Der aus 120 FPGAs bestehende Parallelrechner `F33f`_`[Copacobana`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Copacobana]`_`f ist ein solcher Parallelcomputer zum Codebrechen.

Die inzwischen erreichbare Anzahl von Logikblöcken erlaubt die Integration mehrerer eingebetteter Computersysteme in einen einzigen FPGA-Baustein inklusive CPU(s), Bussystem(en), RAM, ROM, RAM-Controller, Peripherie-Controller etc. Solche kompletten Systeme werden als `F33f`_`[System-on-a-Chip`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=System-on-a-Chip]`_`f (SoC) bezeichnet. Auf Grund ihrer Rekonfigurierbarkeit bilden die SRAM- und Flash-basierten FPGAs die Grundlage für `F33f`_`[rekonfigurierbare Computer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Reconfigurable_Computing]`_`f.

`F33f`_`[Digitale Speicheroszilloskope`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Oszilloskop]`_`f werden oft mit FPGAs realisiert, da deren Stückzahlen meist zu gering sind, um für alle schnellen Komponenten einen ASIC zu entwerfen. Diese verwenden pro Kanal mehrere `F33f`_`[A/D-Wandler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=A/D-Wandler]`_`f parallel, welche das zu messende Signal phasenverschoben abtasten. Das erfordert ein sehr hohes Maß an paralleler Datenverarbeitung und -speicherung, wofür FPGAs gut geeignet sind. Oszilloskope auf FPGA-Basis können beispielsweise auf sehr kurze Impulse unterhalb der Abtastrate der A/D-Wandler triggern oder diese zählen.

Ein Vorteil bei der Verwendung von FPGAs liegt generell auch darin, dass anders als bei `F33f`_`[DSPs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Digitaler_Signalprozessor]`_`f verhältnismäßig geringe Entwicklungskosten bei Neuentwürfen entstehen, falls einer der verwendeten ICs nicht mehr erhältlich ist und dessen Funktion in einen existenten Baustein integriert werden kann.

FPGAs werden sehr häufig auch als Entwicklungsplattform für den digitalen Teil von ASICs verwendet, um die Funktion zu verifizieren. Das ist nötig, da aufgrund der Komplexität heutiger Schaltungen alleinige Simulationen zu zeitaufwändig wären.

Viele Veröffentlichungen aus unterschiedlichsten Anwendungsgebieten berichten über Migration einer Anwendung von Software nach `F33f`_`[Configware`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Configware]`_`f mit Beschleunigungsfaktoren von einer bis zu vier Größenordnungen. Deshalb finden FPGAs Eingang beim `F33f`_`[Reconfigurable Computing`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Reconfigurable_Computing]`_`f und beim Ersatz von Mikrocontrollern.

Ein besonders auf FPGA-Entwicklungsysteme zugeschnittener Tochterkartenstandard ist die `F33f`_`[FPGA Mezzanine Card`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=FPGA_Mezzanine_Card]`_`f.

FPGAs kommen auch beim `F33f`_`[Krypto-Mining`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mining_Rig]`_`f zum Einsatz. Dabei werden Kryptowährungen wie beispielsweise `F33f`_`[Bitcoin`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bitcoin]`_`f, `F33f`_`[Litecoin`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Litecoin]`_`f, `F33f`_`[Ethereum`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ethereum]`_`f oder `F33f`_`[Monero`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Monero]`_`f „geschürft“.`:cite-ref-wallstre-371526-8-0[`F5bf`_`[8`#cite-note-wallstre-371526-8]`_`f]

Die Hardwareplattform MiSTer benutzt FPGAs, um eine große Anzahl an älteren Computern, Spielkonsolen und Arcade-Automaten zu simulieren.

>>Geschichte

Als `*Field Programmable Gate Array`* wurden zunächst zu Beginn der 1980er Jahre einfache Anordnungen von Logikgattern bezeichnet, z. B. das `*82S150/151`* (`F33f`_`[Signetics`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Signetics]`_`f, `F33f`_`[Valvo`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Valvo]`_`f). Dabei handelte es sich um Schaltungen ohne Flipflops oder Lookup-Tabellen, welche mittels `F33f`_`[Fuse-Technologie`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=One_Time_Programmable]`_`f einmalig programmiert werden konnten.`:cite-ref-signeticsfusedlogic-9-0[`F5bf`_`[9`#cite-note-signeticsfusedlogic-9]`_`f] FPGAs im heutigen Sinne entwickelten sich Mitte der 1980er Jahre als eigener Teilbereich von `F33f`_`[Halbleiterbauelementen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Halbleiterbauelement]`_`f. Als Vorläufer der FPGAs kann entfernt die schaltungstechnische Kombination von `F33f`_`[Programmable Read-Only Memory`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmable_Read-Only_Memory]`_`f (PROM) und `F33f`_`[programmierbaren logischen Schaltungen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierbare_logische_Schaltung]`_`f (`F33f`_`[englisch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Englische_Sprache]`_`f programmable logic device, PLD) betrachtet werden.`:cite-ref-fhist1-10-0[`F5bf`_`[10`#cite-note-fhist1-10]`_`f] Die Kombination von reprogrammierbaren Speicherelementen zur Realisierung von logischen Verknüpfungen in Form eines „Array“ auf einem Halbleiterchip wurde von David Westminster Page und LuVerne R. Peterson 1985 patentiert, aber nicht kommerziell umgesetzt.`:cite-ref-pat1-11-0[`F5bf`_`[11`#cite-note-pat1-11]`_`f]`:cite-ref-pat2-12-0[`F5bf`_`[12`#cite-note-pat2-12]`_`f]

Der erste kommerziell verfügbare FPGA war der Baustein `*XC2064`*, der von `F33f`_`[Ross Freeman`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ross_Freeman]`_`f und Bernard Vonderschmitt, beide Gründer des Unternehmens `F33f`_`[Xilinx`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Xilinx]`_`f, im Jahr 1985 entwickelt wurde.`:cite-ref-clarke1-13-0[`F5bf`_`[13`#cite-note-clarke1-13]`_`f] Der XC2064 bestand aus 64 konfigurierbaren Logikblöcken, sogenannten `F33f`_`[Configurable Logic Blocks`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Configurable_Logic_Block]`_`f (CLBs), mit je einer `F33f`_`[Lookup-Tabelle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Lookup-Tabelle]`_`f (LUT) mit drei Eingängen. Die Logikblöcke waren in einer 8×8-Matrix (Array) angeordnet und konnten über schaltbare Verbindungsleitungen kontaktiert werden. Im Jahr 2009 wurde Freeman für die Entwicklung des ersten FPGAs in die US-amerikanische `F33f`_`[National Inventors Hall of Fame`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=National_Inventors_Hall_of_Fame]`_`f aufgenommen.`:cite-ref-nihf1-14-0[`F5bf`_`[14`#cite-note-nihf1-14]`_`f]

>>Vergleiche

>>>Mikroprozessoren

FPGAs bilden je nach Konfiguration beliebige Anordnungen digitaler Schaltungsfunktionen ab und bieten damit grundsätzlich die Möglichkeit, Informationen vollkommen parallel zu verarbeiten. So können die anfallenden Datenflüsse in Bandbreite und Informationstiefe optimal einander angepasst werden. Schnell zu erfassende Signale werden dabei oft voll parallel mit Kopien identischer Schaltungsblöcke, langsamer auftretende Signale vermehrt zyklisch mit einer einzigen Schaltung und damit platzsparend verarbeitet.

Externe Prozessoren können dagegen mit wenig Hardware sehr komplexe und verschachtelte Programme sequentiell abarbeiten. Bei einem FPGA müsste für jede Operation ein eigenes Stück Hardware synthetisiert werden, wobei sich die eingeschränkte Anzahl an Logikgattern begrenzend auswirkt, zudem ist der Aufbau einer vergleichbar flexiblen Struktur äußerst schwierig und zeitaufwändig. Daher bedient man sich bei komplexeren Aufgaben einer sogenannten soft core CPU, die in das FPGA-Design eingebunden wird. Diese gleicht den externen CPUs und stellt eine standardisierte Struktur bereit, die in klassischer Weise in `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f programmiert werden. Heutige FPGAs sind teilweise so leistungsfähig, dass man eine Vielzahl an 8-, 16- oder 32-Bit-CPU-Kernen integrieren kann. Allerdings beanspruchen komplexere CPU-Kerne je nach Konfiguration recht viele Logikressourcen, was sich neben den Kosten in relativ geringer Verarbeitungsleistung verglichen mit Standardprozessoren niederschlägt. Daher gibt es inzwischen FPGAs, die einen oder mehrere hardware-basierte CPU-Kerne enthalten. Nach ersten Anläufen mit `F33f`_`[ARM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ARM-Architektur]`_`f-9 (Altera) und `F33f`_`[PowerPC`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=PowerPC]`_`f405 (Xilinx) geht der Trend seit 2010 in Richtung ARM-Cortex-Architektur. Bei Altera und Xilinx haben sich sogenannte SoC-FPGAs mit Dual-Core-Cortex-A9 und fest integrierter Peripherie etabliert. Xilinx bietet in der High-End-Klasse mit der UltraScale-Familie Bausteine an, die zwei CPU-Cluster (QuadCore Cortex-A53 und DualCore Cortex-R5) enthalten. `F33f`_`[Microsemi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsemi]`_`f hingegen integriert `F33f`_`[RISC-V`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=RISC-V]`_`f Prozessoren (vier Linux-taugliche RV64GC-Kerne und einen RV64IMAC-Kern für Echtzeitanwendungen) in seine Polar-Fire-Familie.

Im Gegensatz zu FPGAs sind Single-Core-Prozessoren reine endliche `F33f`_`[Zustandsautomaten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zustandsautomat]`_`f, die mit einer festgelegten Hardware auskommen müssen und ihr Programm sequentiell abarbeiten, woraus sich auch wesentliche Unterschiede bei der Implementierung von Algorithmen ergeben. Mikroprozessorbausteine beinhalten neben dem eigentlichen Prozessorwerk in der Regel eine feste Peripherie, die direkt genutzt werden kann, und für viele Standardanwendungen ausreichend ist.

Ältere Prozessoren (wie der wie zum Beispiel der Intel i7-3930K aus dem Jahr 2011) mit `F33f`_`[SIMD`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SIMD]`_`f-Befehlen verarbeiten bis zu 192 einfach genaue 32-Bit-`F33f`_`[Gleitkommabefehle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Gleitkomma]`_`f parallel (96 Additionen + 96 Multiplikationen), was einem theretischen Durchsatz von 300 GFlops entspricht. Aktuelle Prozessoren (wie z. B. der AMD EPYC 9655P) liefern bis zu 16.000 GFlops, aktuelle Graphikkarten (`F33f`_`[Nvidia`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Nvidia]`_`f RTX Pro 600) bis zu 126.000 TFlops. Aktuelle FPGAs können mit Taktfrequenzen von 500 MHz zehntausende Festkommaadditionen (bis 48 bit) und tausende Festkommamultiplikationen (bis 18 × 25 bit) zur gleichen Zeit ausführen. Damit ist für Aufgaben, die sich mit Festkommaarithmetik bearbeiten lassen, eine um den Faktor 2 bis 3 höhere Verarbeitungsleistung möglich, bei deutlich geringerer Leistungsaufnahme.

>>>Vor- und Nachteile im Vergleich zu anwendungsspezifischen integrierten Schaltungen (ASIC)

>>>>Vorteile

• Deutlich geringere Entwicklungskosten (im Gegensatz zu `F33f`_`[ASICs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Anwendungsspezifische_integrierte_Schaltung]`_`f werden keine Masken mit sehr hohen Fixkosten benötigt).

• bei Prototypen und Kleinserien sehr kostengünstig.

• Dynamisches, applikationsspezifisches Laden unterschiedlicher Hardware-Designs.

• Kürzere Implementierungszeiten.

• Einfach korrigier- und erweiterbar (rekonfigurierbar).

• Geringeres Designrisiko, da es nicht lange vor der Hardwareauslieferung fertig sein muss

• flexible IO-Ports und Standards, d. h. bei technischen Änderungen der Umgebung anpassbar.

>>>>Nachteile

• Ab mittleren Stückzahlen höherer Stückpreis (als ASICs).

• Geringere Taktraten (aktuell verfügbar bis 1,5 GHz, typisch werden 20–500 MHz realisiert; digitale ASICs bieten >3 GHz).

• Geringere Logikdichte (ca. 10-facher Flächenbedarf gegenüber ASIC gleicher Technologie).

• Geringere mögliche Komplexität der programmierbaren Logik.

• Deutlich höherer Leistungsbedarf für gleiche Menge an Logik bzw. Funktionen.

• Höhere Empfindlichkeit gegenüber Teilchenstrahlung und elektromagnetischen Wellen (da über RAM-Zellen und nicht durch Hartverdrahtung programmiert).

• Geringere Flexibilität, was Ausstattung z. B. mit eingebettetem Speicher oder analogen Elementen angeht, aber auch bei IO-Buffern.

• Der kürzere Designzyklus und die Möglichkeit, sehr spät noch Fehler korrigieren zu können, verleiten dazu, im Vorfeld weniger funktionale Tests durchzuführen.

• `F33f`_`[SRAM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Statisches_RAM]`_`f-basierte FPGAs (das sind z. B. alle von den Marktführern `F33f`_`[Xilinx`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Xilinx]`_`f und `F33f`_`[Altera`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Altera]`_`f angebotenen) müssen bei jeder Spannungsunterbrechung neu geladen werden. Das bedeutet, dass die Funktionalität nicht direkt nach dem Einschalten zur Verfügung steht. Das Laden kann – je nach eingesetzter Technik – bis zu einigen Sekunden dauern. Handelt es sich nicht um spezielle FPGAs mit integriertem Flashspeicher, sind dazu zusätzliche, externe Komponenten notwendig, z. B. ein herstellerspezifisches `F33f`_`[EEPROM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=EEPROM]`_`f oder `F33f`_`[Flash-Speicher`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Flash-Speicher]`_`f, das die Konfiguration enthält oder ein `F33f`_`[Mikrocontroller`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mikrocontroller]`_`f mit zusätzlichem Flash-Speicher, der den Ladevorgang durchführt.

>>Hersteller von FPGAs

• Aeroflex – Strahlungsresistente FPGAs

• Achronix Semiconductor – Sehr schnelle FPGAs (bis 1,5 GHz) in 22 nm

• Abound Logic – Stromsparende FPGAs mit hoher Logikdichte

• `F33f`_`[Altera`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Altera]`_`f (`F33f`_`[Intel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Intel]`_`f) – seit 1983 FPGA-Produzent. Anbieter eines Migrationspfads vom FPGA MAX10, Cyclone, Arria, Agilex und Stratix bis zu strukturierten ASICs

• Cologne Chip AG – Deutscher Anbieter von Low-Power FPGAs mit neuartiger Architektur.

• Efinix – Anbieter von Low-Power-SRAM-FPGAs mit einzigartiger Quantum-Architektur für geringe Verlustleistung und kleine Gehäuse.

• GOWIN Semiconductor – FPGAs mit geringer Zahl an Logikblöcken, nichtflüchtige und SRAM-basierte, `F33f`_`[SoC`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=System-on-a-Chip]`_`f mit Bluetooth

• `F33f`_`[Lattice`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Lattice_Semiconductor_Corporation]`_`f – Anbieter eines freien 32 Bit-`F33f`_`[Open-Source`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Open_Source]`_`f-SoftCore-Prozessors sowie von `F33f`_`[GAL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Generic_Array_Logic]`_`f-Technik. Hat SiliconBlue aufgekauft`:cite-ref-15[`F5bf`_`[15`#cite-note-15]`_`f] (Stromsparende FPGAs der iCE Familie)

• `F33f`_`[Microchip`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microchip_Technology]`_`f (früher: `F33f`_`[Atmel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Atmel]`_`f & `F33f`_`[Actel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Actel]`_`f bzw. `F33f`_`[Microsemi`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsemi]`_`f) – FPGAs, auch mit zusätzlich integriertem RAM und AVR-Mikrocontroller

• NanoXplore – Strahlungsresistente FPGAs

• QuickLogic – seit 1988 Anbieter von stromsparenden FPGAs

• `F33f`_`[Xilinx`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Xilinx]`_`f (seit 2022: AMD) – seit 1984 FPGA-Produzent. Marktführer, bietet das am weitesten ausgebaute `F33f`_`[SOPC`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SOPC]`_`f-System, 2022 von AMD übernommen

>>Siehe auch

• `F33f`_`[CRUVI FPGA Card`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=CRUVI_FPGA_Card]`_`f FPGA-Tochterkartenstandard

>>Literatur

• Rajeev Murgai u. a.: `*Logic Synthesis for Field-Programmable Gate Arrays.`* Springer, 2012, ISBN 978-1-4613-5994-4.

• Zoran Salcic u. a.: `*Digital Systems Design and Prototyping Using Field Programmable Logic.`* Springer, 1997/2013, ISBN 978-1-4613-7807-5.

• Uwe Meyer-Baese: `*Digital Signal Processing with Field Programmable Gate Arrays (Signals and Communication Technology).`* 4th Edition, 2014, Springer, ISBN 978-3-642-45308-3.

• Esteban Tlelo Cuautle u. a.: `*Engineering Applications Of Fpgas (Chaotic Systems, Artificial Neural Networks, Random Number Gener...).`* Springer, 2016, ISBN 978-3-319-34113-2.

>>Weblinks

Commons

: Field-programmable gate arrays

– Sammlung von Bildern, Videos und Audiodateien

• FPGA-Grundlagen bei mikrocontroller.net

• FAQ von comp.arch.fpga Liste mit häufig gestellten Fragen (englisch)

• FPGA-Datenbank des Unternehmens So-Logic (englisch)

• Zur Einführung von FPGA in den US-Markt auf computerhistory (englisch)

>>Einzelnachweise

`:cite-note-1`!1.`! `F0af`_`[↑`#cite-ref-1]`_`f Martin J. W. Schubert: `*Praktikumsversuch – Field Programmable Analog Array (FPAA).`* (PDF; 445 kB) Electronics Laboratory Regensburg University of Applied Sciences, abgerufen am 25. Juli 2020 (englisch).

`:cite-note-xilinxdsp-2`!2.`! `F0af`_`[↑`#cite-ref-xilinxdsp-2-0]`_`f Xilinx User Guide: `*7 Series DSP48E1 Slice`* (PDF, abgerufen am 10. Oktober 2020)

`:cite-note-alteradsp-3`!3.`! `F0af`_`[↑`#cite-ref-alteradsp-3-0]`_`f Altera Whitepaper: `*Enabling High-Performance DSP Applications with Stratix Variable-Precision DSP Blocks`* (PDF, abgerufen am 10. Oktober 2020)

`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f Erwin Böhmer/Dietmar Ehrhardt/Wolfgang Oberschelp: Elemente der angewandten Elektronik, Vieweg Verlag Wiesbaden, 2007, 15. Auflage, Anmerkungen zu PAL/PLD/GAL/CPLD S. 418

`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f Damm, Klauer, Waldschmidt: `*LogiFlash.`* Goethe-Universität Frankfurt am Main, 2018, abgerufen am 21. Juli 2020.

`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f `*MyHDL - open source HDL.`* MYHDL.ORG, 2020, abgerufen am 21. Juli 2020 (englisch).

`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f `*ModelSim®.`* Mentor, 2020, abgerufen am 21. Juli 2020 (englisch).

`:cite-note-wallstre-371526-8`!8.`! `F0af`_`[↑`#cite-ref-wallstre-371526-8-0]`_`f Business Wire (dt.): `*BitHull überholt den ASIC-Markt mit neuen FPGA-Minern.`* In: `*wallstreet-online.de.`* 3. April 2020, abgerufen am 13. Oktober 2020.

`:cite-note-signeticsfusedlogic-9`!9.`! `F0af`_`[↑`#cite-ref-signeticsfusedlogic-9-0]`_`f http://www.bitsavers.org/components/signetics/_dataBooks/1981_Integrated_Fuse_Logic.pdf.pdf Signetics: `*Integrated Fuse Logic`*, Nov. 1981 (PDF). bitsavers.org; abgerufen am 4. Okt. 2020

`:cite-note-fhist1-10`!10.`! `F0af`_`[↑`#cite-ref-fhist1-10-0]`_`f `*History of FPGAs.`* VT.EDU, 13. Juni 2006, archiviert vom Original (nicht mehr online verfügbar) am 13. Juni 2007; abgerufen am 11. Juli 2013 (englisch).

`:cite-note-pat1-11`!11.`! `F0af`_`[↑`#cite-ref-pat1-11-0]`_`f Patent US4508977: `*Re-programmable PLA.`* Veröffentlicht am 2. April 1985, Erfinder: David W. Page, LuVerne R. Peterson.‌

`:cite-note-pat2-12`!12.`! `F0af`_`[↑`#cite-ref-pat2-12-0]`_`f Patent US4524430: `*Dynamic data re-programmable PLA.`* Veröffentlicht am 18. Juni 1985, Erfinder: David W. Page.‌

`:cite-note-clarke1-13`!13.`! `F0af`_`[↑`#cite-ref-clarke1-13-0]`_`f `*Xilinx, ASIC vendors talk licensing.`* Abgerufen am 11. Juli 2013.

`:cite-note-nihf1-14`!14.`! `F0af`_`[↑`#cite-ref-nihf1-14-0]`_`f `*National Inventors Hall of Fame, Ross Freeman.`* Archiviert vom Original (nicht mehr online verfügbar) am 25. September 2012; abgerufen am 11. Juli 2013.

`:cite-note-15`!15.`! `F0af`_`[↑`#cite-ref-15]`_`f `*Lattice Semiconductor Acquires Chipmaker SiliconBlue For $62 Million In Cash.`* In: `*`F33f`_`[TechCrunch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=TechCrunch]`_`f.`* 9. Dezember 2011, abgerufen am 11. April 2019 (englisch).

`c`F0af`_`[↑ Back to top`#top]`_`f`a